{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 【吴恩达课后编程作业】Course1-Week2 ：猫识别"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "from do_not_src.lr_utils import load_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "train_set_x_orig , train_set_y , test_set_x_orig , test_set_y , classes = load_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### do_not_src.lr_utils code:\n",
    "\n",
    "\n",
    "\n",
    "```python\n",
    "import numpy as np\n",
    "import h5py\n",
    "\n",
    "def load_dataset():\n",
    "    \n",
    "    \"\"\"\n",
    "    ...\n",
    "    \"\"\"\n",
    "    \n",
    "    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes\n",
    "```\n",
    "\n",
    "\n",
    "* load_dataset()返回值的含义：\n",
    "\n",
    "train_set_x_orig|train_set_y_orig|test_set_x_orig|test_set_y_orig|classes\n",
    ":--:|:--:|:--:|:--:|:--:\n",
    "训练集里面的图像数据|训练集的图像对应的分类值(0/1)|测试集里面的图像数据|测试集的图像对应的分类值(0/1)|两个字符串数据(b'non-cat’ b’cat’)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fac5e32b410>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "index = 13\n",
    "plt.imshow(train_set_x_orig[index])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "<class 'numpy.ndarray'>\n",
      "y=[1] , it's a cat picture\n"
     ]
    }
   ],
   "source": [
    "# 打印出当前的训练标签值\n",
    "# 使用np.squeeze的目的是压缩维度，【未压缩】train_set_y[:,index]的值为[1]\n",
    "#                             【压缩后】np.squeeze(train_set_y[:,index])的值为1\n",
    "# print(\"【使用np.squeeze：\" + str(np.squeeze(train_set_y[:,index])) + \"，不使用np.squeeze： \" + str(train_set_y[:,index]) + \"】\")\n",
    "# 只有压缩后的值才能进行解码操作\n",
    "print(type(train_set_x_orig))\n",
    "print(type(train_set_y))\n",
    "print(\"y=\" + str(train_set_y[:,index]),\n",
    "      \", it's a\", classes[np.squeeze(train_set_y[:,index])].decode(\"utf-8\"),\n",
    "      \"picture\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集的数量：m_train =  209\n",
      "测试集的数量：m_test =  50\n",
      "每张图片的高/宽：m_train =  64\n",
      "训练集　图片的维数:  (209, 64, 64, 3)\n",
      "训练集　标签的维数:  (1, 209)\n",
      "测试集　图片的维数:  (50, 64, 64, 3)\n",
      "测试集　标签的维数:  (1, 50)\n"
     ]
    }
   ],
   "source": [
    "m_train = train_set_y.shape[1]\n",
    "m_test = test_set_y.shape[1]\n",
    "num_px = train_set_x_orig.shape[1]\n",
    "\n",
    "print('训练集的数量：m_train = ',str(m_train))\n",
    "print('测试集的数量：m_test = ',str(m_test))\n",
    "print('每张图片的高/宽：m_train = ',str(num_px))\n",
    "print('训练集　图片的维数: ', train_set_x_orig.shape)\n",
    "print('训练集　标签的维数: ', train_set_y.shape)\n",
    "print('测试集　图片的维数: ', test_set_x_orig.shape)\n",
    "print('测试集　标签的维数: ', test_set_y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集降维最后的维度： (12288, 209)\n",
      "训练集_标签的维数 : (1, 209)\n",
      "测试集降维之后的维度: (12288, 50)\n",
      "测试集_标签的维数 : (1, 50)\n"
     ]
    }
   ],
   "source": [
    "# X_flatten = X.reshape(X.shape [0]，-1).T ＃X.T是X的转置\n",
    "# 将训练集的维度降低并转置。\n",
    "train_set_x_flatten  = train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T\n",
    "# 将测试集的维度降低并转置。\n",
    "test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T\n",
    "\n",
    "print (\"训练集降维最后的维度： \" + str(train_set_x_flatten.shape))\n",
    "print (\"训练集_标签的维数 : \" + str(train_set_y.shape))\n",
    "print (\"测试集降维之后的维度: \" + str(test_set_x_flatten.shape))\n",
    "print (\"测试集_标签的维数 : \" + str(test_set_y.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 标准化数据集\n",
    "train_set_x = train_set_x_flatten / 255\n",
    "test_set_x = test_set_x_flatten / 255"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 建立神经网络的主要步骤是：\n",
    "\n",
    "* 定义模型结构（例如输入特征的数量）\n",
    "\n",
    "* 初始化模型的参数\n",
    "\n",
    "* 循环：\n",
    "\n",
    "   * 计算当前损失（正向传播）\n",
    "\n",
    "   * 计算当前梯度（反向传播）\n",
    "\n",
    "   * 更新参数（梯度下降）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 构建sigmoid()函数\n",
    "def sigmoid(z):\n",
    "    \"\"\"\n",
    "    参数：\n",
    "        z  - 任何大小的标量或numpy数组。\n",
    "    \n",
    "    返回：\n",
    "        s  -  sigmoid（z）\n",
    "    \"\"\"\n",
    "    s = 1/(1 + np.exp(-z))\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=============测试sigmoid==============\n",
      "sigmoid(0) = 0.5\n",
      "sigmoid(9.2) = 0.9998989708060922\n",
      "sigmoid(-9.2) = 0.00010102919390777289\n"
     ]
    }
   ],
   "source": [
    "#测试sigmoid()\n",
    "print(\"=============测试sigmoid==============\")\n",
    "print (\"sigmoid(0) = \" + str(sigmoid(0)))\n",
    "print (\"sigmoid(9.2) = \" + str(sigmoid(9.2)))\n",
    "print (\"sigmoid(-9.2) = \" + str(sigmoid(-9.2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_with_zeros(dim):\n",
    "    \"\"\"\n",
    "        此函数为w创建一个维度为（dim，1）的0向量，并将b初始化为0。\n",
    "        \n",
    "        参数：\n",
    "            dim  - 我们想要的w矢量的大小（或者这种情况下的参数数量）\n",
    "        \n",
    "        返回：\n",
    "            w  - 维度为（dim，1）的初始化向量。\n",
    "            b  - 初始化的标量（对应于偏差）\n",
    "    \"\"\"\n",
    "    w = np.zeros(shape = (dim,1))\n",
    "    b = 0\n",
    "    #使用断言来确保我要的数据是正确的\n",
    "    assert(w.shape == (dim, 1)) #w的维度是(dim,1)\n",
    "    assert(isinstance(b, float) or isinstance(b, int)) #b的类型是float或者是int\n",
    "    \n",
    "    return (w , b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def propagate(w, b, X, Y):\n",
    "    \"\"\"\n",
    "    实现前向和后向传播的成本函数及其梯度。\n",
    "    参数：\n",
    "        w  - 权重，大小不等的数组（num_px * num_px * 3，1）\n",
    "        b  - 偏差，一个标量\n",
    "        X  - 矩阵类型为（num_px * num_px * 3，训练数量）\n",
    "        Y  - 真正的“标签”矢量（如果非猫则为0，如果是猫则为1），矩阵维度为(1,训练数据数量)\n",
    "\n",
    "    返回：\n",
    "        cost- 逻辑回归的负对数似然成本\n",
    "        dw  - 相对于w的损失梯度，因此与w相同的形状\n",
    "        db  - 相对于b的损失梯度，因此与b的形状相同\n",
    "    \"\"\"\n",
    "    m = X.shape[1]\n",
    "    \n",
    "    #正向传播\n",
    "    A = sigmoid(np.dot(w.T,X) + b) #计算激活值，请参考公式2。\n",
    "    cost = (- 1 / m) * np.sum(Y * np.log(A) + (1 - Y) * (np.log(1 - A))) #计算成本，请参考公式3和4。\n",
    "    \n",
    "    #反向传播\n",
    "    dw = (1 / m) * np.dot(X, (A - Y).T) #请参考视频中的偏导公式。\n",
    "    db = (1 / m) * np.sum(A - Y) #请参考视频中的偏导公式。\n",
    "    \n",
    "    #使用断言确保我的数据是正确的\n",
    "    assert(dw.shape == w.shape)\n",
    "    assert(db.dtype == float)\n",
    "    cost = np.squeeze(cost)\n",
    "    assert(cost.shape == ())\n",
    "    \n",
    "    #创建一个字典，把dw和db保存起来。\n",
    "    grads = {\n",
    "                \"dw\": dw,\n",
    "                \"db\": db\n",
    "             }\n",
    "    return (grads , cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===============测试propagate===============\n",
      "dw = [[0.99993216]\n",
      " [1.99980262]]\n",
      "db = 0.49993523062470574\n",
      "cost = 6.000064773192205\n"
     ]
    }
   ],
   "source": [
    "print(\"===============测试propagate===============\")\n",
    "#初始化一些参数\n",
    "w, b, X, Y = np.array([[1], [2]]), 2, np.array([[1,2], [3,4]]), np.array([[1, 0]])\n",
    "grads, cost = propagate(w, b, X, Y)\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))\n",
    "print (\"cost = \" + str(cost))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize(w , b , X , Y , num_iterations , learning_rate , print_cost = False):\n",
    "    \"\"\"\n",
    "    此函数通过运行梯度下降算法来优化w和b\n",
    "    \n",
    "    参数：\n",
    "        w  - 权重，大小不等的数组（num_px * num_px * 3，1）\n",
    "        b  - 偏差，一个标量\n",
    "        X  - 维度为（num_px * num_px * 3，训练数据的数量）的数组。\n",
    "        Y  - 真正的“标签”矢量（如果非猫则为0，如果是猫则为1），矩阵维度为(1,训练数据的数量)\n",
    "        num_iterations  - 优化循环的迭代次数\n",
    "        learning_rate  - 梯度下降更新规则的学习率\n",
    "        print_cost  - 每100步打印一次损失值\n",
    "    \n",
    "    返回：\n",
    "        params  - 包含权重w和偏差b的字典\n",
    "        grads  - 包含权重和偏差相对于成本函数的梯度的字典\n",
    "        成本 - 优化期间计算的所有成本列表，将用于绘制学习曲线。\n",
    "    \n",
    "    提示：\n",
    "    我们需要写下两个步骤并遍历它们：\n",
    "        1）计算当前参数的成本和梯度，使用propagate（）。\n",
    "        2）使用w和b的梯度下降法则更新参数。\n",
    "    \"\"\"\n",
    "    \n",
    "    costs = []\n",
    "    \n",
    "    for i in range(num_iterations):\n",
    "        \n",
    "        grads, cost = propagate(w, b, X, Y)\n",
    "        \n",
    "        dw = grads[\"dw\"]\n",
    "        db = grads[\"db\"]\n",
    "        \n",
    "        w = w - learning_rate * dw\n",
    "        b = b - learning_rate * db\n",
    "        \n",
    "        #记录成本\n",
    "        if i % 100 == 0:\n",
    "            costs.append(cost)\n",
    "        #打印成本数据\n",
    "        if (print_cost) and (i % 100 == 0):\n",
    "            print(\"迭代的次数: %i ， 误差值： %f\" % (i,cost))\n",
    "        \n",
    "    params  = {\n",
    "                \"w\" : w,\n",
    "                \"b\" : b }\n",
    "    grads = {\n",
    "            \"dw\": dw,\n",
    "            \"db\": db } \n",
    "    return (params , grads , costs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===============测试optimize===============\n",
      "w = [[0.1124579 ]\n",
      " [0.23106775]]\n",
      "b = 1.5593049248448891\n",
      "dw = [[0.90158428]\n",
      " [1.76250842]]\n",
      "db = 0.4304620716786828\n"
     ]
    }
   ],
   "source": [
    "print(\"===============测试optimize===============\")\n",
    "w, b, X, Y = np.array([[1], [2]]), 2, np.array([[1,2], [3,4]]), np.array([[1, 0]])\n",
    "params , grads , costs = optimize(w , b , X , Y , num_iterations=100 , learning_rate = 0.009 , print_cost = False)\n",
    "print (\"w = \" + str(params[\"w\"]))\n",
    "print (\"b = \" + str(params[\"b\"]))\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(w , b , X ):\n",
    "    \"\"\"\n",
    "    使用学习逻辑回归参数logistic （w，b）预测标签是0还是1，\n",
    "    \n",
    "    参数：\n",
    "        w  - 权重，大小不等的数组（num_px * num_px * 3，1）\n",
    "        b  - 偏差，一个标量\n",
    "        X  - 维度为（num_px * num_px * 3，训练数据的数量）的数据\n",
    "    \n",
    "    返回：\n",
    "        Y_prediction  - 包含X中所有图片的所有预测【0 | 1】的一个numpy数组（向量）\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    m  = X.shape[1] # 图片的数量\n",
    "    Y_prediction = np.zeros((1,m)) \n",
    "    w = w.reshape(X.shape[0],1)\n",
    "    \n",
    "    # 计预测猫在图片中出现的概率\n",
    "    A = sigmoid(np.dot(w.T , X) + b)\n",
    "    for i in range(A.shape[1]):\n",
    "        # 将概率a [0，i]转换为实际预测p [0，i]\n",
    "        Y_prediction[0,i] = 1 if A[0,i] > 0.5 else 0\n",
    "    # 使用断言\n",
    "    assert(Y_prediction.shape == (1,m))\n",
    "    \n",
    "    return Y_prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===============测试predict===============\n",
      "predictions = [[1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "print(\"===============测试predict===============\")\n",
    "w, b, X, Y = np.array([[1], [2]]), 2, np.array([[1,2], [3,4]]), np.array([[1, 0]])\n",
    "print(\"predictions = \" + str(predict(w, b, X)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(X_train , Y_train , X_test , Y_test , num_iterations = 2000 , learning_rate = 0.5 , print_cost = False):\n",
    "    \"\"\"\n",
    "    通过调用之前实现的函数来构建逻辑回归模型\n",
    "    \n",
    "    参数：\n",
    "        X_train  - numpy的数组,维度为（num_px * num_px * 3，m_train）的训练集\n",
    "        Y_train  - numpy的数组,维度为（1，m_train）（矢量）的训练标签集\n",
    "        X_test   - numpy的数组,维度为（num_px * num_px * 3，m_test）的测试集\n",
    "        Y_test   - numpy的数组,维度为（1，m_test）的（向量）的测试标签集\n",
    "        num_iterations  - 表示用于优化参数的迭代次数的超参数\n",
    "        learning_rate  - 表示optimize（）更新规则中使用的学习速率的超参数\n",
    "        print_cost  - 设置为true以每100次迭代打印成本\n",
    "    \n",
    "    返回：\n",
    "        d  - 包含有关模型信息的字典。\n",
    "    \"\"\"\n",
    "    w , b = initialize_with_zeros(X_train.shape[0])\n",
    "    \n",
    "    parameters , grads , costs = optimize(w , b , X_train , Y_train,num_iterations , learning_rate , print_cost)\n",
    "    \n",
    "    # 从字典“参数”中检索参数w和b\n",
    "    w , b = parameters[\"w\"] , parameters[\"b\"]\n",
    "    \n",
    "    # 预测测试/训练集的例子\n",
    "    Y_prediction_test = predict(w , b, X_test)\n",
    "    Y_prediction_train = predict(w , b, X_train)\n",
    "    \n",
    "    # 打印训练后的准确性\n",
    "    print(\"训练集准确性：\"  , format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100) ,\"%\")\n",
    "    print(\"测试集准确性：\"  , format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100) ,\"%\")\n",
    "    \n",
    "    d = {\n",
    "            \"costs\" : costs,\n",
    "            \"Y_prediction_test\" : Y_prediction_test,\n",
    "            \"Y_prediciton_train\" : Y_prediction_train,\n",
    "            \"w\" : w,\n",
    "            \"b\" : b,\n",
    "            \"learning_rate\" : learning_rate,\n",
    "            \"num_iterations\" : num_iterations }\n",
    "    # 绘制图\n",
    "    costs = np.squeeze(d['costs'])\n",
    "    plt.plot(costs)\n",
    "    plt.ylabel('cost')\n",
    "    plt.xlabel('iterations (per hundreds)')\n",
    "    plt.title(\"Learning rate =\" + str(d[\"learning_rate\"]))\n",
    "    plt.show()\n",
    "\n",
    "    \n",
    "    return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "====================测试model====================\n",
      "learning rate is: 0.005\n",
      "迭代的次数: 0 ， 误差值： 0.693147\n",
      "迭代的次数: 100 ， 误差值： 0.584508\n",
      "迭代的次数: 200 ， 误差值： 0.466949\n",
      "迭代的次数: 300 ， 误差值： 0.376007\n",
      "迭代的次数: 400 ， 误差值： 0.331463\n",
      "迭代的次数: 500 ， 误差值： 0.303273\n",
      "迭代的次数: 600 ， 误差值： 0.279880\n",
      "迭代的次数: 700 ， 误差值： 0.260042\n",
      "迭代的次数: 800 ， 误差值： 0.242941\n",
      "迭代的次数: 900 ， 误差值： 0.228004\n",
      "迭代的次数: 1000 ， 误差值： 0.214820\n",
      "迭代的次数: 1100 ， 误差值： 0.203078\n",
      "迭代的次数: 1200 ， 误差值： 0.192544\n",
      "迭代的次数: 1300 ， 误差值： 0.183033\n",
      "迭代的次数: 1400 ， 误差值： 0.174399\n",
      "迭代的次数: 1500 ， 误差值： 0.166521\n",
      "迭代的次数: 1600 ， 误差值： 0.159305\n",
      "迭代的次数: 1700 ， 误差值： 0.152667\n",
      "迭代的次数: 1800 ， 误差值： 0.146542\n",
      "迭代的次数: 1900 ， 误差值： 0.140872\n",
      "训练集准确性： 99.04306220095694 %\n",
      "测试集准确性： 70.0 %\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deXxV9Z3/8dcnCUlISEJWliSEHQoqopFFbMWlFq11acWlWq22pZvT6TKLv19nWsdO59dlZjpttdOxrp1a99aitbUuqEVECMgiAhLWhLCEPeyEfH5/nBO8xJuQQO69Se77+XjcR3LP+d57P/fk5r7P+v2auyMiIskrJdEFiIhIYikIRESSnIJARCTJKQhERJKcgkBEJMkpCEREkpyCQHokM/uTmd2S6DpEugMFgXQqM1tnZhcnug53v9TdH050HQBm9qqZfT4Or5NhZg+Y2R4z22xm3zxB+2+E7XaHj8uImDfYzGaZ2X4zWxH5NzWzz5rZUTPbG3GbGsO3JjGmIJBux8zSEl1Ds65UC3AnMAKoAC4A/sHMpkVraGYfA+4ALgIGA0OBf4lo8ijwNlAIfBt4ysyKI+a/6e59Im6vdu5bkXhSEEjcmNnlZrbIzHaZ2RwzOyNi3h1mttrMGszsXTO7OmLeZ83sDTP7iZntAO4Mp802s383s51mttbMLo14zLG18Ha0HWJmr4ev/ZKZ3WNmv2nlPUw1s1oz+0cz2ww8aGb5ZvacmdWHz/+cmZWF7b8PfBi4O1xzvjucPtrMXjSzHWa20syu7YRFfDPwPXff6e7LgV8Bn22l7S3A/e6+zN13At9rbmtmI4GzgO+6+wF3fxpYCnyqE2qULkhBIHFhZmcBDwBfJFjL/B9gZsTuiNUEX5h5BGumvzGzARFPMRFYA5QA34+YthIoAn4E3G9m1koJbbX9LTAvrOtO4DMneDv9gQKCNe8ZBP9HD4b3BwEHgLsB3P3bwF+B28M159vNLBt4MXzdEuAG4BdmNjbai5nZL8LwjHZbErbJBwYCiyMeuhiI+pzh9JZt+5lZYThvjbs3tPFc481sm5m9Z2b/3MW2jKSDFAQSL18A/sfd33L3o+H++0PAJAB3f9Ld69y9yd0fB1YBEyIeX+fuP3f3Rnc/EE5b7+6/cvejwMPAAKBfK68fta2ZDQLOAb7j7ofdfTYw8wTvpYlgbflQuMa83d2fdvf94Zfn94Hz23j85cA6d38wfD8LgaeBa6I1dvevuHvfVm7NW1V9wp+7Ix66G8hppYY+UdoStm85r+VzvQ6cRhBinyIIsr9v4/1KF6cgkHipAL4VuTYLlBOsxWJmN0fsNtpF8EVTFPH4mijPubn5F3ffH/7aJ0q7ttoOBHZETGvttSLVu/vB5jtmlmVm/2Nm681sD8EXZV8zS23l8RXAxBbL4kaCLY2TtTf8mRsxLRdoiNK2uX3LtoTtW8477rncfY27rw1DeylwF62EmHQPCgKJlxrg+y3WZrPc/VEzqyDYn307UOjufYF3gMjdPLHqJncTUGBmWRHTyk/wmJa1fAsYBUx091zgI+F0a6V9DfBai2XRx92/HO3FzOyXLc7QibwtAwj3828CxkU8dBywrJX3sCxK2y3uvj2cN9TMclrMb+25nOP/VtLNKAgkFnqZWWbELY3gi/5LZjbRAtlm9vHwyyab4MukHsDMbiXYIog5d18PVBEcgE43s8nAJzr4NDkExwV2mVkB8N0W87cQnJXT7DlgpJl9xsx6hbdzzOxDrdT4pRZn6ETeIvfb/xr4p/Dg9WiC3XEPtVLzr4HPmdmY8PjCPzW3dff3gEXAd8O/39XAGQS7rzCzS82sX/j7aOCfgT+0YzlJF6UgkFh4nuCLsfl2p7tXEXwx3Q3sBKoJz1Jx93eB/wDeJPjSPB14I4713ghMBrYD/wo8TnD8or3+C+gNbAPmAn9uMf+nwDXhGUU/C48jXAJcD9QR7Lb6IZDBqfkuwUH39cBrwI/d/c8AZjYo3IIYBBBO/xEwK2y/nuMD7HqgkuBv9QPgGnevD+ddBCwxs30Ef+vfAf92irVLApkGphE5npk9Dqxw95Zr9iI9krYIJOmFu2WGmVmKBRdgXQk8k+i6ROJF5/6KBGfr/I7gOoJa4Mvu/nZiSxKJH+0aEhFJcto1JCKS5LrdrqGioiIfPHhwossQEelWFixYsM3di6PN63ZBMHjwYKqqqhJdhohIt2Jm61ubp11DIiJJTkEgIpLkFAQiIkkupkFgZtPCQTeqzeyOKPN/EvY4uSjs13xXLOsREZEPitnB4rAL3nuAjxJcpDPfzGaG/coA4O7fiGj/N8D4WNUjIiLRxXKLYAJQHfZdfhh4jODS/dbcQDBOqoiIxFEsg6CU4wf4qA2nfUDYH/0Q4JVW5s8wsyozq6qvr4/WRERETlIsgyDaQBWt9WdxPfBUOIzgBx/kfq+7V7p7ZXFx1OshTmhxzS5++OcVJ/VYEZGeLJZBUMvxIz2VEfS9Hs31xHi30OLaXfz3q6tZXKPj0SIikWIZBPOBEWY2xMzSCb7sPzAouJmNAvIJBiWJmavHl5KVnspv5rZ6cZ2ISFKKWRC4eyPBGLQvAMuBJ9x9mZndZWZXRDS9AXjMY9wNak5mL64aX8rMxXXs2n84li8lItKtxPQ6And/3t1Huvswd/9+OO077j4zos2d7v6Bawxi4aaJFRxqbOKpBbXxeDkRkW4hqa4sHjMwl7Mr8nnkrQ00NWkcBhERSLIgAPjMpArWbtvHnNXbE12KiEiXkHRBcOnp/SnITud/565LdCkiIl1C0gVBRloq0yvLeGn5VjbtPpDockREEi7pggDgxgkVNLnz6LyaEzcWEenhkjIIBhVmcf7IYh6bt4EjR5sSXY6ISEIlZRBAcNB4a8MhXnx3S6JLERFJqKQNgqmjSijt21tXGotI0kvaIEhNMT49cRBzVm+neuveRJcjIpIwSRsEANedU06vVOORt7RVICLJK6mDoKhPBpeeNoCnFtSy/3BjossREUmIpA4CgJsmVdBwsJFnF7fWQ7aISM+W9EFwzuB8RvXL4X/nrifGHaCKiHRJSR8EZsZNkwbxzsY9LK7dnehyRETiLumDAOCq8aVka9AaEUlSCgLeH7TmWQ1aIyJJSEEQummSBq0RkeSkIAh9aEAulRX5/Gbueg1aIyJJRUEQ4aZJFazbvp83Vm9LdCkiInGjIIhwbNCaN3XQWESSh4IgQkZaKtdWlvPS8i0atEZEkoaCoIUbJw7CgUff2pDoUkRE4kJB0EJ5QRZTRxbz6PwaDVojIklBQRDFZyZXUN9wiL8s06A1ItLzKQiiOH+kBq0RkeShIIgiNcW4cdIg3lyzneqtDYkuR0QkpmIaBGY2zcxWmlm1md3RSptrzexdM1tmZr+NZT0dcW1lMGjNb+bqoLGI9GwxCwIzSwXuAS4FxgA3mNmYFm1GAP8HmOLuY4Gvx6qejmoetObphRq0RkR6tlhuEUwAqt19jbsfBh4DrmzR5gvAPe6+E8Ddt8awng77zORg0JqZizRojYj0XLEMglKgJuJ+bTgt0khgpJm9YWZzzWxaDOvpsMoKDVojIj1fLIPAokxr+W2aBowApgI3APeZWd8PPJHZDDOrMrOq+vr6Ti+0NWbGTZMrWFa3h0U1u+L2uiIi8RTLIKgFyiPulwEt97HUAn9w9yPuvhZYSRAMx3H3e9290t0ri4uLY1ZwNFcfG7RGB41FpGeKZRDMB0aY2RAzSweuB2a2aPMMcAGAmRUR7CpaE8OaOqxPRhpXn1XKs0vq2LlPg9aISM8TsyBw90bgduAFYDnwhLsvM7O7zOyKsNkLwHYzexeYBfy9u2+PVU0n66ZJFRzWoDUi0kNZdzsIWllZ6VVVVXF/3em/nMPWhkPM+tZUUlKiHf4QEem6zGyBu1dGm6cri9vpxokVrN++n7lru9wGi4jIKVEQtNO00/qTk5nGU1XaPSQiPYuCoJ0ye6XyiXEDef6dTew5eCTR5YiIdBoFQQdcW1nOwSNN/HHJpkSXIiLSaRQEHTCuLI8RJX14oqrmxI1FRLoJBUEHmBnXVpbz9oZd6p5aRHoMBUEHXTW+lNQU40kdNBaRHkJB0EHFORlcOLqEpxdu1JjGItIjKAhOwvSzy9i29xCvrYxfB3giIrGiIDgJF4wuoahPOk8u0EFjEen+FAQnoVdqClePL+Xl5VvZtvdQossRETklCoKTNL2ynMYm55m3Nya6FBGRU6IgOEkj++UwrrwvT1bVavQyEenWFASnYPrZZazc0sDSjbsTXYqIyElTEJyCT4wbSEZaiq40FpFuTUFwCvJ692Laaf2ZuaiOg0eOJrocEZGToiA4RddWlrPnYCN/eXdLoksRETkpCoJTNHloIaV9e/Okdg+JSDelIDhFKSnGNWeXMbt6Gxt3HUh0OSIiHaYg6ATXnF2GOzytwe1FpBtSEHSC8oIszh1WyFMLamlq0jUFItK9KAg6yfTKMjbs2M9ba3ckuhQRkQ5REHSSaWMHkJORpo7oRKTbURB0kt7pqVw+biDPL91Egwa3F5FuREHQia6tLNPg9iLS7SgIOtGZ5X0ZrsHtRaSbURB0IjNj+tllLNywi+qtexNdjohIu8Q0CMxsmpmtNLNqM7sjyvzPmlm9mS0Kb5+PZT3xcPVZ4eD2OmgsIt1EzILAzFKBe4BLgTHADWY2JkrTx939zPB2X6zqiZeSnEwuGFXM7xZupFGD24tINxDLLYIJQLW7r3H3w8BjwJUxfL0uY3plOfUNh3jtPQ1uLyJdXyyDoBSI3D9SG05r6VNmtsTMnjKz8mhPZGYzzKzKzKrq67v+l+uFo0sozE7nySp1OSEiXV8sg8CiTGvZ/8KzwGB3PwN4CXg42hO5+73uXunulcXFxZ1cZuc7Nrj9ii1s1+D2ItLFxTIIaoHINfwyoC6ygbtvd/fmb8pfAWfHsJ64ml5ZzpGjzjOL6k7cWEQkgWIZBPOBEWY2xMzSgeuBmZENzGxAxN0rgOUxrCeuRvXPYVxZHk9W1WhwexHp0mIWBO7eCNwOvEDwBf+Euy8zs7vM7Iqw2dfMbJmZLQa+Bnw2VvUkwjWV5azY3MA7G/ckuhQRkVZZd1tbrays9KqqqkSX0S67Dxxhwvdf4rpzyrnrytMSXY6IJDEzW+DuldHm6criGMrr3YuPje3PM29v1OD2ItJlKQhirHlw+xc1uL2IdFEKghg7d1gwuL06ohORrkpBEGMpKcanwsHt6zS4vYh0QQqCOJiuwe1FpAtTEMRBeUEWk4YW8KQGtxeRLkhBECc3TBjEhh37eWm5DhqLSNeiIIiTj58+gMGFWfzslVW60lhEuhQFQZykpabw1QuG887GPcxauTXR5YiIHKMgiKOrxpdSXtCbn75cra0CEekyFARx1Cs1ha9OHc7iml28vmpbossREQEUBHH3ybPKKO3bm5++9J62CkSkS1AQxFl6WgpfnjqMhRt2MWf19kSXIyKiIEiE6ZVl9M/N5Kcvr0p0KSIiCoJEyEhL5ctThzFv7Q7mrtFWgYgkloIgQa47p5ySnAx+pq0CEUmwdgWBmU1vzzRpv8xeqXzx/GHMWb2d+et2JLocEUli7d0i+D/tnCYd8OkJgyjqk66tAhFJqLS2ZprZpcBlQKmZ/SxiVi7QGMvCkkHv9FRmfGQo//b8ChZu2MlZg/ITXZKIJKETbRHUAVXAQWBBxG0m8LHYlpYcbpxYQX5WL36urQIRSZA2twjcfTGw2Mx+6+5HAMwsHyh3953xKLCny85I4/MfHsqPX1jJktpdnFHWN9EliUiSae8xghfNLNfMCoDFwINm9p8xrCup3Dy5grzevfjZy9WJLkVEklB7gyDP3fcAnwQedPezgYtjV1ZyycnsxefOG8JLy7fwzsbdiS5HRJJMe4MgzcwGANcCz8WwnqR1y7mDyclM4+5XtFUgIvHV3iC4C3gBWO3u881sKKCjm50or3cvbp0yhD8v28yKzXsSXY6IJJF2BYG7P+nuZ7j7l8P7a9z9U7EtLfncNmUwfTLS+Lm2CkQkjtp7ZXGZmf3ezLaa2RYze9rMymJdXLLpm5XOLedW8PzSTaza0pDockQkSbR319CDBNcODARKgWfDaW0ys2lmttLMqs3sjjbaXWNmbmaV7aynx/rceUPp3SuVu2dpq0BE4qO9QVDs7g+6e2N4ewgobusBZpYK3ANcCowBbjCzMVHa5QBfA97qUOU9VEF2Op+ZXMGzi+tYXb830eWISBJobxBsM7ObzCw1vN0EnKj/5AlAdXg84TDwGHBllHbfA35EcPWyAF/48FDS01K4R1sFIhIH7Q2C2whOHd0MbAKuAW49wWNKgZqI+7XhtGPMbDzBVcptnpJqZjPMrMrMqurr69tZcvdV1CeDmyZW8IdFdazbti/R5YhID9feIPgecIu7F7t7CUEw3HmCx1iUaccG6TWzFOAnwLdO9OLufq+7V7p7ZXFxm3ukeowZHxlKWorxi1e1VSAisdXeIDgjsm8hd98BjD/BY2qB8oj7ZQSd2DXLAU4DXjWzdcAkYKYOGAdKcjO5YcIgfrdwIzU79ie6HBHpwdobBClhZ3MAhH0OtdlhHTAfGGFmQ8wsHbie4MwjANx9t7sXuftgdx8MzAWucPeqDr2DHuxL5w8jxYxfvLo60aWISA/W3iD4D2COmX3PzO4C5hAc4G2VuzcCtxNckbwceMLdl5nZXWZ2xakUnSz652Vy3TnlPLWgho27DiS6HBHpoczdT9wKCE/9vJBg3//L7v5uLAtrTWVlpVdVJc9Gw8ZdB5j641lcf84gvnfVaYkuR0S6KTNb4O5Rd72faPfOMeEXf0K+/JNZad/eXHN2OY/Pr+GrFwynf15moksSkR6mvbuGJIG+MnUYTe788jUdKxCRzqcg6AbKC7L45Fml/HbeBhZu0MBwItK5FATdxN9dMooBeZncfP88FqxXGIhI51EQdBMluZk8NmMShX3SueWBeSxYvyPRJYlID6Eg6EYG5PXm8RmTKeqTHm4ZKAxE5NQpCLqZ/nmZPDZjMiW5wW6iqnUKAxE5NQqCbqh/XiaPfmESJbmZ3PLAPOYrDETkFCgIuqlgy2AS/cIwmLdWYSAiJ0dB0I31Cw8g98/L5LMPzuOtNScaIkJE5IMUBN1cSW4mj31hEgPyMrn1ofkKAxHpMAVBD1CSm8mjM4Iw+OyD85mrMBCRDlAQ9BAlOUEYlOb35tYH5/PmaoWBiLSPgqAHKckJziYqy+/NbQ/NZ87qbYkuSUS6AQVBD1Ock8FvI8OgWmEgIm1TEPRAxTkZPDpjEoMKsrjt4fm8oTAQkTYoCHqooj7BlkFFQTa3PaQwEJHWKQh6sCAMJjKkKAiD2asUBiLyQQqCHq6wTwaPfD4Mg4fnc8+sag43NiW6LBHpQhQESaCwTwaPfmESF3+ohB+/sJLLf/5X9VwqIscoCJJEfnY6v7jxbO67uZK9Bxu55pdv8u3fL2X3gSOJLk1EEkxBkGQuHtOPF795PreeO4RH523go//5Gs8v3YS7J7o0EUkQBUESys5I4zufGMMfvnoexTkZfOWRhXz+4So27jqQ6NJEJAEUBEns9LI8/vDVKXz7sg8xZ/V2Pvqfr3H/7LUcbdLWgUgyURAkubTUFL7wkaH85RsfYeKQAr733Ltcdc8bvLNxd6JLE5E4URAIAOUFWTzw2XO4+9Pj2bT7IFfcPZt/fe5d9h1qTHRpIhJjCgI5xsy4/IyBvPzN87nunEHcN3stl/zkdWat2Jro0kQkhmIaBGY2zcxWmlm1md0RZf6XzGypmS0ys9lmNiaW9Uj75GX14v998nSe/NJkeqencutD8/nqbxeyteFgoksTkRiwWJ02aGapwHvAR4FaYD5wg7u/G9Em1933hL9fAXzF3ae19byVlZVeVVUVk5rlgw41HuV/XlvD3a9Uk5GWwhfPH8qtU4aQnZGW6NJEpAPMbIG7V0abF8stgglAtbuvcffDwGPAlZENmkMglA3odJUuJiMtla9dNII/f/3DTBxawL//5T3O//EsHpi9loNHjia6PBHpBLEMglKgJuJ+bTjtOGb2VTNbDfwI+Fq0JzKzGWZWZWZV9fX1MSlW2ja0uA/33XIOv/vKuYwoyeGu597lwn9/lcfnb6DxqPouEunOYhkEFmXaB9b43f0edx8G/CPwT9GeyN3vdfdKd68sLi7u5DKlI84alM+jMybxyOcnUpybyT8+vZSP/uR1Zi6uo0nXH4h0S7EMglqgPOJ+GVDXRvvHgKtiWI90oinDi3jmK+dy72fOJj01ha89+jaX/eyvvLx8i7qrEOlmYhkE84ERZjbEzNKB64GZkQ3MbETE3Y8Dq2JYj3QyM+OSsf15/m8/zH9ddyYHjhzlcw9X8cn/nqPxkkW6kZid+uHujWZ2O/ACkAo84O7LzOwuoMrdZwK3m9nFwBFgJ3BLrOqR2ElNMa4aX8rHzxjAk1W1/OzlVXz6V29x3vAi/u5jozizvG+iSxSRNsTs9NFY0emjXd/BI0f5zdz13DOrmp37j3DJmH5865JRjOqfk+jSRJJWW6ePKggkZhoOHuGB2eu4769r2Hu4kSvHDeSL5w/jQwNyE12aSNJREEhC7dx3mF++vppfz1nPgSNHmTK8kM+dN4SpI0tISYl2cpmIdDYFgXQJu/Yf5rfzNvDwnHVs2XOIocXZ3DZlCJ86q4ze6amJLk+kR1MQSJdyuLGJ55du4r7Za3hn4x76ZvXipokV3Dy5gpLczESXJ9IjKQikS3J35q3dwf2z1/Li8i2kpRifOGMgt503hNNK8xJdnkiP0lYQqOcwSRgzY+LQQiYOLWTdtn08NGcdT1TV8Lu3NzJpaAGfP28oF47WcQSRWNMWgXQpu/cf4bH5G3hozjo27T7IkKJsbpsymE+dXUZWutZbRE6Wdg1Jt3PkaBN/emcz9/91DYtrd5PXuxc3TBjEDRPKqSjMTnR5It2OgkC6LXdnwfqd3D97LS8s20yTw8QhBVxbWc6lp/fXVoJIOykIpEfYtPsAv1u4kSeqali/fT99MtK4/IwBTK8s56xBfTHTsQSR1igIpEdxd+av28kTVTX8cckmDhw5yrDibK6tLOfqs0opydEpqCItKQikx9p7qJE/LqnjyapaqtbvJDXFuGBUCdMry7hwdAm9UmM6LLdIt6EgkKSwun4vT1bV8vTCWuobDlHUJ52rx5cyvbKckf3U4Z0kNwWBJJXGo0289l49T1bV8tLyLTQ2OePK+zL97DIuO30ABdnpiS5RJO4UBJK0tu09xDNvBweY39uyl9QU49xhhXz89AF8bGx/8hUKkiQUBJL03J1ldXt4fukm/rh0E+u371coSFJREIhEaA6FPy7dxPMtQuHyMwZwyRiFgvQ8CgKRVkQLhbQU49zhRXz89P4KBekxFAQi7RAZCn9csokNOxQK0nMoCEQ6qDkUnlsSbCls2BHsPqqsyOeiD5Vw4egShhX30dXM0m0oCEROgbvzzsY9/OmdTbyyYisrNjcAMKggiwtHl3DB6BImDikgs5dGWZOuS0Eg0ok27jrArBVbmbViK2+s3sbBI01kpacyZXgRF44Othb6aaQ16WIUBCIxcvDIUd5cvZ1XVmzllRVb2bjrAABjB+ZyUbi1MK6srwbXkYRTEIjEgbvz3pa9vLxiC7NWbGXB+p00ORRmpzN1VLClMGV4IX2zdMBZ4k9BIJIAO/cd5vVV9byyYiuvrqxn94EjmAVbC1OGFXHu8CImDC6gd7qOLUjsKQhEEqzxaBOLanbxRvV23li9jbc37OTIUadXqjF+UD7nDS9iyvBCzijrqx5TJSYUBCJdzP7Djcxft5M51dt4Y/U2ltXtwR2y01OZOLSQc4cVMmV4EaP65ej4gnSKtoIgpuP8mdk04KdAKnCfu/+gxfxvAp8HGoF64DZ3Xx/LmkS6gqz0NM4fWcz5I4uBYDfSm2u280b1NuaEB58hOL4weVhhuMVQRFl+b127IJ0uZlsEZpYKvAd8FKgF5gM3uPu7EW0uAN5y9/1m9mVgqrtf19bzaotAkkHdrgPHQuGN6m1sbTgEwIC8TCoHF3DO4HzOGVzAyH45pGqLQdohUVsEE4Bqd18TFvEYcCVwLAjcfVZE+7nATTGsR6TbGNi3N9Mry5leWY67U711L2+u2c68tTuYt3Y7zy6uAyAnM42zK4JQOGdwAWeU5enCNumwWAZBKVATcb8WmNhG+88Bf4o2w8xmADMABg0a1Fn1iXQLZsaIfjmM6JfDzZMH4+7U7jxA1fodzFu7k6p1O3h15UoA0lNTOL0sLwyGfM6uyNfpqnJCsQyCaNurUfdDmdlNQCVwfrT57n4vcC8Eu4Y6q0CR7sjMKC/Iorwgi6vHlwHBMYYF63cyf90O5q/bwf2z1/DL14J/lVH9cqgMdyWdWd6XisIsHWeQ48QyCGqB8oj7ZUBdy0ZmdjHwbeB8dz8Uw3pEeqz87HQuHtOPi8f0A4IrnhfX7KJq/U7mrd3BzEV1PPLWBgD6ZvViXFlfziwPbuPK+2r4ziQXy4PFaQQHiy8CNhIcLP60uy+LaDMeeAqY5u6r2vO8Olgs0nFHm5z3tjSwqGYXi2t2sahmF+9taaAp/PcfVJDFuPK+jCvLY/ygvowdqGMNPU3CriMws8uA/yI4ffQBd/++md0FVLn7TDN7CTgd2BQ+ZIO7X9HWcyoIRDrHvkONLN24+1gwLK7ZRd3ugwCkpRijB+QwrizYYhhf3pdhxX10TUM3pgvKRKRdtu45GIRCbRAOS2p203CoEYA+GWmMGZDL2NJcxg7M47TSXIYV99GV0N1Ewi4oE5HupSQ3k0vG9ueSsf0BaGpy1mzby6KaYMthWd1uHp23gYNHmgBIT0thdP8cxg7MY+zAXE4rzWN0/xztVupmtEUgIh1ytMlZu20vy+r28M7G3Syr28Oyuj3sPnAEgNQUY3hxH8YOzGVMGA5jBuaSm9krwZUnN+0aEpGYar62IQiF3cd+btnz/omAgwqyGN0/h9H9cxjVP5dR/XMYXJhFmnYtxYV2DYlITEVe2zDttP7Hptc3HDoWDO/W7WHF5j28tARYykgAAAylSURBVHzLsbOVMtJSGNGvD6P65YYBEQRFcU6GrnWII20RiEhcHTxylOqte1mxuYGVm/eEPxuO9acEkJ/VKwyFYMthVP8cRvXLITtD664nS1sEItJlZPZK5bTSPE4rzTtu+s59h4+Fw8otDSzf1MATVTXsP3z0WJvSvr0ZVtKHESV9GN58K+5Dvi6IOyUKAhHpEvLDLrcnDys8Nq2pKTj2sGLzHlZubqC6fi/VW/cyb+32Y2cuART1SWdYcRAMQUjkMLykD/1ytYupPRQEItJlpaQYgwqzGFSYdeyUVggCYuOuA1Rv3XvstmprA88urmPPwcZj7XIy0hgWsfUwtCibocXZlBdkkZGmU1ybKQhEpNtJSXn/4PQFo0uOTXd36vceOi4gqrfu5fX36nlqQe37jzcoy89iSFE2Q8JwaP59YF7vpLuCWkEgIj2GmVGSk0lJTibnDis6bt7uA0dYt20fa7ftY034c+22vVSt28G+iOMQGWkpDC4MgyEMiKFhSBRkp/fIXU0KAhFJCnm9ewUd65X3PW66u1PfcCgiHPaxpn4fq7Y28PKKLRw5+v6ZlTkZaZQXZFER7q6qKMimojC4PyCvd7cdLU5BICJJzcwoyc2kJDeTSUMLj5vXeLSJjbsOsCYMhw3b97F+x35Wbm7gpeXHh0SvVKM8vzkgshhUmE1FGBrlBVldutsNBYGISCvSUlOoKMymojCbC0YdP+9ok7Np9wE2bN/P+h37Wb99Pxt27GP99v0sWLfzWGd9zfrnZlJe0Jvy/CzK8ntTlp9FWXh/QF5mQq+wVhCIiJyE1BQLvszzszi3xTx3Z+f+I6zfvo8NYUis376f2p37eWvtDp5ZdODY1dXNz9U/N5Oy/N6UFwRBcSwwCrLon5sZ091OCgIRkU5mZhRkp1OQnc74QfkfmH/kaBObdx+kZsd+anceoGZn+HPHfmav2saWhoNEdvqQlmIM7Nubb10ykivPLO30ehUEIiJx1is15djpr9EcajxK3a6D1O7cT82OA8HPnQco6pMRk3oUBCIiXUxGWuqx6xriQf2/iogkOQWBiEiSUxCIiCQ5BYGISJJTEIiIJDkFgYhIklMQiIgkOQWBiEiS63aD15tZPbD+JB9eBGzrxHI6m+o7Narv1HX1GlXfyatw9+JoM7pdEJwKM6ty98pE19Ea1XdqVN+p6+o1qr7Y0K4hEZEkpyAQEUlyyRYE9ya6gBNQfadG9Z26rl6j6ouBpDpGICIiH5RsWwQiItKCgkBEJMn1yCAws2lmttLMqs3sjijzM8zs8XD+W2Y2OI61lZvZLDNbbmbLzOxvo7SZama7zWxRePtOvOoLX3+dmS0NX7sqynwzs5+Fy2+JmZ0Vx9pGRSyXRWa2x8y+3qJN3JefmT1gZlvN7J2IaQVm9qKZrQp/fnDMwqDdLWGbVWZ2S5xq+7GZrQj/fr83s76tPLbNz0KMa7zTzDZG/B0va+Wxbf6/x7C+xyNqW2dmi1p5bFyW4Slx9x51A1KB1cBQIB1YDIxp0eYrwC/D368HHo9jfQOAs8Lfc4D3otQ3FXgugctwHVDUxvzLgD8BBkwC3krg33ozwYUyCV1+wEeAs4B3Iqb9CLgj/P0O4IdRHlcArAl/5oe/58ehtkuAtPD3H0arrT2fhRjXeCfwd+34DLT5/x6r+lrM/w/gO4lchqdy64lbBBOAandf4+6HgceAK1u0uRJ4OPz9KeAiM7N4FOfum9x9Yfh7A7Ac6PzRqGPrSuDXHpgL9DWzAQmo4yJgtbuf7JXmncbdXwd2tJgc+Tl7GLgqykM/Brzo7jvcfSfwIjAt1rW5+1/cvTG8Oxco68zX7KhWll97tOf//ZS1VV/43XEt8Ghnv2689MQgKAVqIu7X8sEv2mNtwn+G3UBhXKqLEO6SGg+8FWX2ZDNbbGZ/MrOxcS0MHPiLmS0wsxlR5rdnGcfD9bT+z5fI5desn7tvgmAFACiJ0qYrLMvbCLbwojnRZyHWbg93Xz3Qyq61rrD8PgxscfdVrcxP9DI8oZ4YBNHW7FueI9ueNjFlZn2Ap4Gvu/ueFrMXEuzuGAf8HHgmnrUBU9z9LOBS4Ktm9pEW87vC8ksHrgCejDI70cuvIxK6LM3s20Aj8EgrTU70WYil/waGAWcCmwh2v7SU8M8icANtbw0kchm2S08MglqgPOJ+GVDXWhszSwPyOLnN0pNiZr0IQuARd/9dy/nuvsfd94a/Pw/0MrOieNXn7nXhz63A7wk2vyO1ZxnH2qXAQnff0nJGopdfhC3Nu8zCn1ujtEnYsgwPTF8O3OjhzuyW2vFZiBl33+LuR929CfhVK6+d0M9i+P3xSeDx1tokchm2V08MgvnACDMbEq41Xg/MbNFmJtB8dsY1wCut/SN0tnB/4v3Acnf/z1ba9G8+ZmFmEwj+TtvjVF+2meU0/05wUPGdFs1mAjeHZw9NAnY37wKJo1bXwhK5/FqI/JzdAvwhSpsXgEvMLD/c9XFJOC2mzGwa8I/AFe6+v5U27fksxLLGyONOV7fy2u35f4+li4EV7l4bbWail2G7JfpodSxuBGe1vEdwNsG3w2l3EXzoATIJdilUA/OAoXGs7TyCTdclwKLwdhnwJeBLYZvbgWUEZ0DMBc6NY31Dw9ddHNbQvPwi6zPgnnD5LgUq4/z3zSL4Ys+LmJbQ5UcQSpuAIwRrqZ8jOO70MrAq/FkQtq0E7ot47G3hZ7EauDVOtVUT7Ftv/gw2n0U3EHi+rc9CHJff/4afryUEX+4DWtYY3v/A/3s86gunP9T8uYtom5BleCo3dTEhIpLkeuKuIRER6QAFgYhIklMQiIgkOQWBiEiSUxCIiCQ5BYHEhJnNCX8ONrNPd/Jz/99orxUrZnZVrHowNbO9MXreqWb23Ck+x0Nmdk0b8283s1tP5TWka1AQSEy4+7nhr4OBDgWBmaWeoMlxQRDxWrHyD8AvTvVJ2vG+Yi68ErazPAB8rROfTxJEQSAxEbGm+wPgw2Ff7N8ws9SwL/z5YWdiXwzbT7VgnIbfElxEhJk9E3bUtay5sy4z+wHQO3y+RyJfK7zS+cdm9k7Y//t1Ec/9qpk9ZUEf/I9EXHn8AzN7N6zl36O8j5HAIXffFt5/yMx+aWZ/NbP3zOzycHq731eU1/h+2EHeXDPrF/E610S02RvxfK29l2nhtNkE3R40P/ZOM7vXzP4C/LqNWs3M7g6Xxx+J6CQv2nLy4IrkdeHV29KNdebagUg0dxD0Kd/8hTmDoEuKc8wsA3gj/IKCoA+W09x9bXj/NnffYWa9gflm9rS732Fmt7v7mVFe65MEHZSNA4rCx7wezhsPjCXoh+YNYIqZvUvQdcFod3eLPjjLFIJO7CINBs4n6BBtlpkNB27uwPuKlA3Mdfdvm9mPgC8A/xqlXaRo76WKoD+eCwmuGm7Z983ZwHnufqCNv8F4YBRwOtAPeBd4wMwK2lhOVQS9b847Qc3ShWmLQOLtEoJ+ihYRdL9dCIwI581r8WX5NTNr7iaiPKJda84DHvWgo7ItwGvAORHPXetBB2aLCL7M9wAHgfvM7JNAtD53BgD1LaY94e5NHnQ7vAYY3cH3Fekw0Lwvf0FY14lEey+jgbXuvsqD7gJ+0+IxM939QPh7a7V+hPeXXx3wSti+reW0laBLBenGtEUg8WbA37j7cR2rmdlUYF+L+xcDk919v5m9StBH1ImeuzWHIn4/SjA6V2O4W+Migs7KbidYo450gKB32kgt+2Vx2vm+ojji7/fzcpT3/ycbCVfUwl0/6W29l1bqihRZQ2u1XhbtOU6wnDIJlpF0Y9oikFhrIBiSs9kLwJct6IobMxtpQa+MLeUBO8MQGE0wJGazI82Pb+F14LpwH3gxwRpuq7ssLBgTIs+Drqq/TrBbqaXlwPAW06abWYqZDSPoVGxlB95Xe60j2J0DwYhb0d5vpBXAkLAmCHpnbU1rtb4OXB8uvwHABeH8tpbTSLpib5rSIdoikFhbAjSGu3geAn5KsCtjYbimW0/0IRz/DHzJzJYQfNHOjZh3L7DEzBa6+40R038PTCbo6dGBf3D3zWGQRJMD/MHMMgnWkr8Rpc3rwH+YmUWsua8k2O3Uj6DnyYNmdl8731d7/SqsbR5Bz6VtbVUQ1jAD+KOZbQNmA6e10ry1Wn9PsKa/lKA3z9fC9m0tpynAv3T43UmXot5HRU7AzH4KPOvuL5nZQ8Bz7v5UgstKODMbD3zT3T+T6Frk1GjXkMiJ/RvBGAhyvCLgnxNdhJw6bRGIiCQ5bRGIiCQ5BYGISJJTEIiIJDkFgYhIklMQiIgkuf8Plyb1PRXzwOYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"====================测试model====================\")     \n",
    "#这里加载的是真实的数据，请参见上面的代码部分。\n",
    "print('learning rate is: 0.005')\n",
    "d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "learning rate is: 0.01\n",
      "训练集准确性： 99.52153110047847 %\n",
      "测试集准确性： 68.0 %\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "-------------------------------------------------------\n",
      "\n",
      "learning rate is: 0.001\n",
      "训练集准确性： 88.99521531100478 %\n",
      "测试集准确性： 64.0 %\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "-------------------------------------------------------\n",
      "\n",
      "learning rate is: 0.0001\n",
      "训练集准确性： 68.42105263157895 %\n",
      "测试集准确性： 36.0 %\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "-------------------------------------------------------\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = [0.01, 0.001, 0.0001]\n",
    "models = {}\n",
    "for i in learning_rates:\n",
    "    print (\"learning rate is: \" + str(i))\n",
    "    models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)\n",
    "    print ('\\n' + \"-------------------------------------------------------\" + '\\n')\n",
    "\n",
    "for i in learning_rates:\n",
    "    plt.plot(np.squeeze(models[str(i)][\"costs\"]), label= str(models[str(i)][\"learning_rate\"]))\n",
    "\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations')\n",
    "\n",
    "legend = plt.legend(loc='upper center', shadow=True)\n",
    "frame = legend.get_frame()\n",
    "frame.set_facecolor('0.90')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
